﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<vector>
#include<unordered_map>

using namespace std;

void f(int& x)
{
	std::cout << "左值引重载 f(" << x << ")\n";
}
void f(const int& x)
{
	std::cout << "到 const 的左值引重载 f(" << x << ")\n";
}
void f(int&& x)
{
	std::cout << "右值引重载 f(" << x << ")\n";
}
//int main()
//{
//	int a = 10;
//	const int b = 20;
//
//	f(a);          // 调用左值引用重载
//	f(b);          // 调用到 const 的左值引用重载
//	f(30);			// 调用右值引用重载
//	f(std::move(a)); // 调用右值引用重载
//
//	return 0;
//}
//int main()
//{
//	const string& ls = string("666");
//	ls[1] = '8';
//
//	return 0;
//}

// 传值返回需要拷⻉
string addStrings(string num1, string num2) {
	string str;
	//...
	return str;
}

vector<vector<int>> generate(int numRows) {
	vector<vector<int>> vv(numRows);
	//...
	return vv;
}

//int main()
//{
//	string s1 = addStrings("666", "999");
//
//	vector<vector<int>> vv = generate(100);
//
//	return 0;
//}

//typedef int& lr;
//typedef int&& rr;
//
//int main()
//{
//	lr& x = 1;  //左值引用不能绑定右值字面量
//	rr& y = 2;  
//	lr&& a = 3; 
//
//	rr&& b = 4; //右值引用可以绑定右值字面量
//
//
//	return 0;
//}

template<class T>
void f1(T& x) 
{}

template<class T>
void f2(T&& x) 
{}

//int main()
//{
//	int n = 10;
//	// 没有折叠->实例化为void f1(int& x)
//	f1<int>(n);
//	f1<int>(0); // 报错
//
//	// 折叠->实例化为void f1(int& x)
//	f1<int&>(n);
//	f1<int&>(0); // 报错
//
//	// 折叠->实例化为void f1(int& x)
//	f1<int&&>(n);
//	f1<int&&>(0); // 报错
//	
//	// 折叠->实例化为void f1(const int& x)
//	f1<const int&>(n);
//	f1<const int&>(0);
//
//	// 没有折叠->实例化为void f2(int&& x)
//	f2<int>(n); // 报错
//	f2<int>(0);
//
//	// 折叠->实例化为void f2(int& x)
//	f2<int&>(n);
//	f2<int&>(0); // 报错
//
//	// 折叠->实例化为void f2(int&& x)
//	f2<int&&>(n); // 报错
//	f2<int&&>(0);
//
//	return 0;
//}

template<class T>
void Function(T&& t)
{
	int a = 0;
	T x = a;
	//x++;
	cout << &a << endl;
	cout << &x << endl << endl;
} 
//int main()
//{
//	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
//	Function(10); // 右值
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
//	Function(a); // 左值
//	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
//	Function(std::move(a)); // 右值
//	const int b = 8;
//	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int&t)
//	// 所以Function内部会编译报错，x不能++
//	Function(b); // const 左值
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
//	// 所以Function内部会编译报错，x不能++
//	Function(std::move(b)); // const 右值
//
//	int a = 1;
//	Function(a);
//
//	Function(0);
//
//	return 0;
//}

template <class _Ty>
_Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept
{ // forward an lvalue as either an lvalue or an rvalue
	return static_cast<_Ty&&>(_Arg);
}

int findMaxLength(vector<int>& nums) {
	unordered_map<int, int> m;
	m[0] = -1;
	int sum = 0, ret = 0, n = nums.size();

	for (int i = 0; i < n; i++) {
		sum += nums[i] == 0 ? -1 : 1;
		if (m.count(sum) == 0) m[sum] = i;
		ret = (i - m[sum]) > ret ? (i - m[sum]) : ret;
	}
	return ret;
}

class Solution2138 {
public:
	vector<string> divideString(string s, int k, char fill) {
		vector<string> ret;
		int i = 0, len = s.size();
		string word;

		while (i < len) {
			word += s[i];
			if ((i + 1) % k == 0) {
				ret.emplace_back(word);
				word.clear();
			}
			i++;
		}
		if (s.size() % k != 0) {
			while (word.size() != k) {
				word += fill;
			}
			ret.emplace_back(word);
		}

		return ret;
	}
};

int main()
{
	vector<int> n{ 0,1,1,1,1,1,0,0,0 };
	cout << findMaxLength(n);
	return 0;
}